#!/usr/bin/evn python
#-*-coding:UTF-8-*-
########################################################################
########################################################################
#                               入口函数pyyjks()
########################################################################
########################################################################
import os
import pyYJKSModel                                                          #导入YJK-pyYJKSModel   help(pyYJKSModel)函数可以查看所有类与函数;
# # import YJKSPre                                                          #前处理模块            发布版暂且不管，需要等戴工处理
import pyYJKSParam                                                          #特殊构件定义模块
import pyYJKCommand                                                         #命令模块
import pyYJKSUI                                                             #用户界面模块
import pyYJKSDesign                                                         #设计结果


def TestBuile():                                                          #建模
    ydb = pyYJKSModel.creatProjEx()                                       #创建工程
    pyYJKSModel.yjkProj.init(ydb)                                         #初始化
    bzc = pyYJKSModel.defBzc()                                            #定义标准层
    bzc.setHeight(3600)                                             #标准层参数设置
    ydb.addBzc(bzc)                                                 #将标准层添加到项目
    defcol = pyYJKSModel.defCol()                                         # 添加柱定义
    defcol.set(1, 500, 500, 0, 0, 0, 0, 0, 6, 0)                    # 柱参数定义
    ydb.addCol(defcol)                                              # 柱定义添加到项目
    defcol2 = pyYJKSModel.defCol()  # 添加柱定义
    defcol2.set(  2, 60, 600, 400, 20, 400, 20, 5, 6, 0)  # 柱参数定义
    ydb.addCol(defcol2)  # 柱定义添加到项目
    defbeam = pyYJKSModel.defBeam()                                       #梁定义
    defbeam.set(1, 300, 550, 0, 0, 0, 0, 0, 6, 0)                   #梁参数定义
    defbeam.getM()                                                  #梁参数获取
    print("defbeam_isSteelSec?",defbeam.isSteelSec())               #查询属性                      #梁参数查看
    ydb.addBeam(defbeam)                                            #梁定义添加到项目
    defwall = pyYJKSModel.defWall()                                       #定义墙
    defwall.setK(1)                                                 #定义墙参数
    defwall.setT(200)                                               #...
    defwall.setM(6)
    ydb.addWall(defwall)                                            #将定义添加到项目
    defHole = pyYJKSModel.defHole()                                       # 板洞定义
    defHole.setK(1)
    defHole.setB(3000)                                              #定义属性
    defHole.setH(3000)                                              #...
    ydb.addHole(defHole)                                            #将洞属性添加到项目
    defHole1 = pyYJKSModel.defHole()  # 板洞定义
    defHole1.setK(1)
    defHole1.setB(6000)  # 定义属性
    defHole1.setH(5000)  # ...
    ydb.addHole(defHole1)  # 将洞属性添加到项目
    defbrace = pyYJKSModel.defBrace()                                     # 添加斜撑定义
    defbrace.set(1, 350, 350, 0, 0, 0, 0, 0, 6, 0)
    ydb.addBrace(defbrace)                                          #将斜撑定义添加到项目
    defwindow = pyYJKSModel.defWindow()                                   # 窗户定义
    defwindow.setB(2200)
    defwindow.setH(1800)
    defwindow.setK(1)
    ydb.addWindow(defwindow)                                        #将窗户信息添加到项目
    defwallhole = pyYJKSModel.defWindow()                                 # 墙洞定义
    defwallhole.setB(3800)
    defwallhole.setH(1800)
    # defwindow.setK(1)
    ydb.addWindow(defwallhole)                                      # 将窗户信息添加到项目
    #                                                               节点创建、网格创建；使用正常网格进程建模测试
    originpos = [0,0]                                               #网格原点
    xspans = [originpos[0], 8000, 6000, 6000, 8000,10000]                 #开间
    yspans = [originpos[1], 8000, 8000, 6000, 6000]                 #进深
    xp = 0                                                          #node
    nodelist = []                                                   #定义数组、使用循环创建节点并添加到数组中
    for nodex in range(len(xspans)):
        yp = 0
        xp += xspans[nodex]
        for nodey in range(len(yspans)):
            node = pyYJKSModel.creatNode()                                #创建节点
            node.setX(xp)                                           #设置参数
            yp += yspans[nodey]
            node.setY(yp)
            node.setEon(0)
            bzc.addEntity(node)                                     #添加到标准层
            col = pyYJKSModel.creatColumn()                               #在节点出建柱子
            col.setNodeID(node.getID())                             #设置节点ID
            col.setDefID(defcol.getID())                           #设置柱子ID
            print(type(col),col.getID())
            bzc.addEntity(col)                                      #标准层添加柱子
            nodelist.insert(len(nodelist), node)                    #将创建的节点添加到数组中
    #                                                               使用循环建立网格
    gridlist = []
    #Grid
    ix = 0
    iy = 0
    wgIdx = 0
    wgIdy = 0
    for ix in range(len(xspans)):                                   #横向网格
        for iy in range(len(yspans)):
            if iy < len(yspans)-1:
                grid = pyYJKSModel.creatGrid()                            # 创建网格定义
                grid.setNode1Ptr(nodelist[wgIdx])                   # 设置第一个点
                grid.setNode2Ptr(nodelist[wgIdx + 1])               # 设置第二个点
                bzc.addEntity(grid)                                 # 将网格添加到标准层
                beam = pyYJKSModel.creatBeam()                            # 在网格上建立梁--创建梁
                beam.setGridID(grid.getID())                        # 设置网格ID
                beam.setDefID(defbeam.getID())                      # 设置梁定义
                bzc.addEntity(beam)                                 # 在标准层添加梁
                wall = pyYJKSModel.creatWall()                            # 在网格上建立墙--创建墙
                wall.setGridID(grid.getID())                        # 设置网格ID
                wall.setDefID(defwall.getID())                      # 设置墙
                bzc.addEntity(wall)                                 # 在标准层添加墙
                wallhole = pyYJKSModel.creatWindow()
                wallhole.setGridID(grid.getID())
                wallhole.setDefID(defwallhole.getID())
                wallhole.setEC(1200)
                wallhole.setEZ(0)
                bzc.addEntity(wallhole)
                brace = pyYJKSModel.creatBrace()                          #在网格基础上建立斜撑
                brace.setDefID(defbrace.getID())
                brace.setNode1ID(nodelist[wgIdy].getID())            #设置斜撑参数
                brace.setNode2ID(nodelist[wgIdy + 1].getID())
                brace.setEX1(0)
                brace.setEX2(0)
                brace.setEY1(0)                                         #...
                brace.setEY2(0)
                brace.setEZ1(0)
                brace.setEZ2(1)
                bzc.addEntity(brace)                                    #在标准层添加斜撑
                wgIdx += 1
                gridlist.insert(len(gridlist),grid)                     # 将创建的网格添加到数组中
            if ix < len(xspans)-1:                                      #纵向网格
                grid1 = pyYJKSModel.creatGrid()
                grid1.setNode1Ptr(nodelist[wgIdy])
                grid1.setNode2Ptr(nodelist[wgIdy + 5])
                bzc.addEntity(grid1)
                beam1 = pyYJKSModel.creatBeam()
                beam1.setGridID(grid1.getID())
                beam1.setDefID(defbeam.getID())
                bzc.addEntity(beam1)
                wall1 = pyYJKSModel.creatWall()                            # 添加墙构件
                wall1.setGridID(grid1.getID())
                wall1.setDefID(defwall.getID())
                bzc.addEntity(wall1)
                brace = pyYJKSModel.creatBrace()
                brace.setDefID(defbrace.getID())
                brace.setNode1ID(nodelist[wgIdy].getID())
                brace.setNode2ID(nodelist[wgIdy + 5].getID())
                brace.setEX1(0)
                brace.setEX2(0)
                brace.setEY1(0)
                brace.setEY2(0)
                brace.setEZ1(0)
                brace.setEZ2(1)
                bzc.addEntity(brace)                                                #添加窗户
                window = pyYJKSModel.creatWindow()
                window.setGridID(grid1.getID())
                window.setDefID(defwindow.getID())
                window.setEC(2200)
                window.setEZ(1000)
                bzc.addEntity(window)
                wgIdy += 1
                gridlist.insert(len(gridlist),grid1)                    # 将创建的网格添加到数组中
        wgIdx += 1
    gridx = 0
    for g in range(len(nodelist)):
        if g % len(xspans)-1 != 0 and g > len(nodelist)-len(xspans):
            pass
        else:
            node_1_y = gridlist[gridx].getNode1Ptr().getY()
            node_2_y = gridlist[gridx].getNode2Ptr().getY()
            node_3_x = gridlist[gridx + 1].getNode1Ptr().getX()  # 获取网格两个节点坐标
            node_4_x = gridlist[gridx + 1].getNode2Ptr().getX()
            slab = pyYJKSModel.creatSlab()
            print("节点编号",gridlist[gridx].getNode1Ptr().getID(),"x",(node_1_y + node_2_y)/2,"y",(node_3_x + node_4_x) / 2)
            slab.setXc((node_1_y + node_2_y) / 2)
            slab.setYc((node_3_x + node_4_x) / 2)
            slab.setThick(200)
            # slab.setGridID(1, grid.getID())
            bzc.addEntity(slab)
            hole = pyYJKSModel.creatHole()
            hole.isRoom()
            hole.setDefID(defHole.getID())
            hole.setSlabID(slab.getID())
            hole.setNodeID(nodelist[g].getID())
            print("nodenode", nodelist[g].getID())
            hole.setAG(0)
            hole.setEX(2000)
            hole.setEY(2000)
            bzc.addEntity(hole)
            if g <(len(nodelist)-len(xspans)):
                gridx = g*2
            print("gridx:",gridx)
    lever = 10
    flheight = 3600
    for r in range(lever):                                          #添加自然层
        zrc = pyYJKSModel.defZrc()
        zrc.setBzcID(bzc.getID())
        zrc.setLevel(flheight*r)
        zrc.setHeight(flheight)
        ydb.addZrc(zrc)
    save = pyYJKSModel.SaveYDB("pymodel", ydb)                      #ydb文件保存，自定义文件名
    print(save)
def LoadTest():                                                     #修改模型
    ydb = pyYJKSModel.LoadYDB("111")
    # bzc= ydb.getBzcPtrByNO(1)
    # print("bzc",bzc)
    # bzc_height = bzc.getHeight()
    # print("bzc_height",bzc_height)
    # bzc.setHeight(6000)
    defbeam2 = pyYJKSModel.defBeam()                              # 梁定义
    defbeam2.set(1, 600, 350, 0, 0, 0, 0, 0, 6, 0)          # 梁参数定义
    defbeam2.getM()  # 梁参数获取
    print("defbeam_isSteelSec?", defbeam2.isSteelSec())     # 查询属性   #梁参数查看
    ydb.addBeam(defbeam2)
    #获取构件
    # getwall = bzc.getGjPtr(1)
    # print("getwall",type(getwall))
    bzclist = pyYJKSModel.getList(-4,ydb)                          #得到模型中的所有标准层 返回列表[]
    if len(bzclist) == 0:
        return
    for v in range(len(bzclist)):
        bzc = pyYJKSModel.yjkBzc.cast(bzclist[v])                  #遍历所有列表，对每个标准层进行操作
        print("第",v+1,"个标准层")
        bzcbeam = bzc.getGjPtr(12)                          #得到标准层中的构件(例为梁)
        print(len(bzcbeam),"个标准层梁bzcbeam")
        for b in range(len(bzcbeam)):
            #beam1 = ydb.findEntFromID(bzcbeam[b].getID()) #通过ID查找构件（梁）
            # print(type(beam),beam.getID())
            beam2 = ydb.getBeamFromID(bzcbeam[b].getID())
            beam2.setDefID(defbeam2.getID())
            grid1 = beam2.getGridPtr()                      #梁得到网格
            getwall_by_grid = grid1.getGridConnectedEnt(1)  #得到网格上的指定构件
            # print(type(getwall_by_grid))
            for w in range(len(getwall_by_grid)):
                pwall = pyYJKSModel.yjkWall.cast(getwall_by_grid[w])
                # print(type(pwall))
        bzc.setHeight(5000)                                 #修改标准层高，注意！标准层高修改后自然层底标高和层高需对应修改，否则标准层修改无效
    zrclist = pyYJKSModel.getList(-5, ydb)                        #获取所有自然层列表
    if len(zrclist) == 0:
        return
    for z in range(len(zrclist)):                           #使用循环对自然层进行操作
        zrc = pyYJKSModel.yjkZrc.cast(zrclist[z])
        # print(zrc.getHeight(),zrc.getLevel())               #查询自然层信息
        zrc.setLevel(z*5000)                                #修改底标高
        zrc.setHeight(5000)                                 #修改层高
    lever = 10                                              #再次加10层
    flheight = 3800
    for r in range(lever):  # 添加自然层
        zrc = pyYJKSModel.defZrc()
        zrc.setBzcID(bzc.getID())
        zrc.setLevel(flheight * r+5000*10)
        zrc.setHeight(flheight)
        ydb.addZrc(zrc)
    save = pyYJKSModel.SaveYDB("ok", ydb)                         #保存修改
    print(save)
                                                              # 建模

def yjksetLabel(IDString):                                                  #切换YJK模块Ribbob菜单
    pyYJKSUI.QSetCurrentRibbonLabel(IDString, 1)
    return 1                                                                #为防止不同模块未切换或切换失败而导致的函数无法执行或软件错误奔溃情况，请判断执行结果再执行下一步操作

def ParamProperty(nEntID,szname):                                          #特殊构件定义与属性查询
    # nEntID 构件ID  szName 特殊构件定义字段 nVt 属性类别(VT_I4/VT_R4(VT_R8)/VT_BSTR) nVal、fVal、strVal根据类型使用不同类型参数值
    # nEntID = 1012
    # szname = "SpColm"
    nvt, nval, fVal, strVal, vecData,
    pyYJKSParam.GetProperty(nEntID, szname, nvt, nval, fVal, 1, vecData)  # 特殊构件查询
    if (nvt == VT_SAFEARRAY):
        if (len(vecData) > 0):
            iProp = vecData[22]                                              # 对照接口查看数组对应含义 【22】空间结构杆件属性
            if iProp == 0:
                eletype = "非桁架"
                print("eletype:", eletype)
            elif iProp == 1:
                eletype = "上弦杆"
                print("eletype:", eletype)
            elif iProp == 2:
                eletype = "腹杆"
                print("eletype:", eletype)
            elif iProp == 3:
                eletype = "中层弦杆"
                print("eletype:", eletype)
            elif iProp == 4:
                eletype = "下弦杆"
                print("eletype:", eletype)
            elif iProp == 5:
                eletype = "支座腹杆"
                print("eletype:", eletype)
    # pyYJKSParam.AddProperty(nEntID, szname, nvt, nval, fVal, strVal, 1)                            #特殊构件定义
    return 1


def calcula_start(culation_type):
    # pyYJKSParam.RunCmd(culation_type)                                       #(方法1：使用前处理中命令运行函数)
    pyYJKCommand.RunCommand(culation_type)                                #(方法2：使用command中命令运行函数)
    return 1
    #---------------calcula_start-参数及对应模式----------------------------------
    #"yjkdesign_dsncalculating_all")                                        # 将生成计算所需数据和全部计算连续进行
    #"yjkdesign_dsncalculating_all")                                        #将生成计算所需数据和全部计算连续进行
    #"ID_YJKDesign_dsnCalculating_Cal_Design")                              #内力计算和构件设计连续进行（已生成数据）
    #"ID_YJKDesign_dsnCalculating_Cal")                                     #只进行内力计算
    #"ID_YJKDesign_dsnCalculating_Design")                                  #只进行构件设计（已作过内力计算）
    #"ID_YJKDesign_dsnCalculating_DesignEnv")                               # 只进行包络设计（已作过构件设计）
    #"ID_YJKDesign_dsnCalculating_CalByParaYJKA")                          # 自定义内力计算部分内容


def pyyjks(com):                                                            #入口函数，功能在此函数里添加
    Module_Axis = yjksetLabel("IDModule_Axis")                              #进入建模模块
    if Module_Axis:
        pyYJKSUI.QViewSetCursorPos(0, 0)                                        #控制鼠标停留在绘图（0，0）
        TestBuile()                                                             #新建ydb模型
    # LoadTest()  # 修改模型
    importmodel = pyYJKSUI.QRunCommandEx("yjk_importydb", "pymodel.ydb", 0) #使用command模块导入已经生成的ydb模型   pymodel
    pyYJKCommand.RunCommand("yjk_setlayersupport")                          # 前处理
    pyYJKCommand.RunCommand("yjk_repairex")                                 #修复
    pyYJKCommand.RunCommand("yjk_save")                                     # 保存到项目
    if importmodel:
        pyYJKSUI.QViewSetCursorPos(0, 0)                                        #控制鼠标停留在绘图（0，0）
    Module_Pre = yjksetLabel("IDSPRE_ROOT")                                 #进入前处理模块
    if Module_Pre:
         # Module_Param_state = ParamProperty(1012, "SpColm")                #特殊构件定义
        # if Module_Param_state:
        calculate_end = calcula_start("yjkdesign_dsncalculating_all")                                   # 将生成计算所需数据和全部计算连续进行(方法1：使用前处理中命令运行函数)
        if calculate_end:
            Module_Desi = pyYJKSUI.QWANGJINCHANG("IDDSN_DSP")                                           #进入设计结果模块
            if Module_Desi:
                # LDCase = pyYJKSDesign.dsnGetLDCaseBySort(...)                                                       #获得排序后设计模块的工况信息
                # print(LDCase)
                Ldkind = pyYJKSDesign.dsnGetLDKind(1)                                                             #根据工况编号获得工况类型  nLDCase工况号
                print(Ldkind)
                pyYJKSDesign.dsnLDCaseIsSeis(1)
                pyYJKSDesign.dsnOutputWallColumnStabilityInf(1,1000050)                                                           #输出墙柱稳定验算文本文件
                pyYJKSUI.QViewSetCursorPos(0, 0)                                                            # 运行完成，控制鼠标停留在绘图（0，0）
    else:
        pass

    console(com, com)
    return (com)



def console(filename,infor):                        #日志文件生成
    path = 'E:\\API\\run\\x64\\Release\\'
    file_path = path + filename + '.log'
    file = open(file_path, 'w')
    file.writelines([infor+ '\n'])
    file.close()



